package cn.handong.tool.algorithm;

import java.util.LinkedList;
import java.util.Objects;
import java.util.Queue;
import java.util.Scanner;


/**
 * 迷宫（最短路问题）
 * 给定一个n*m大小的迷宫，其中*代表不可通过的墙壁，而“.”代表平地，S表示起点，T代表终点。移动过程中，如果当前位置是(x,y)(下标从0开始)，且每次只能前往上下左右、(x,y+1)、(x,y-1)、(x-1,y)、(x+1,y)四个位置的平地，求从起点S到达终点T的最少步数。
 *
 * .....
 * .*.*.
 * .*S*.
 * .***.
 * ...T*
 *
 * 上面样例S为(2,2)，T的坐标为(4,3)。
 *
 *
 */
public class BFSTest {

    static String[][] a;//迷宫
    static Boolean[][]inq;  //是否入过队
    static int[] X={0,0,1,-1};//增量数组
    static int[] Y={1,-1,0,0};
    static Node1 S=new Node1();
    static Node1 T=new Node1();
    //检测位置(x,y)是否有效
    static Boolean test(int x,int y,int n,int m){
        if(x>=n||x<0||y>=m||y<0){ //越界
            return false;
        }
        if(Objects.equals(a[x][y], "*")){ //墙壁
            return false;
        }
        //已入过队
        return !inq[x][y];
    }
    static int bfs(int n,int m){
        Queue<Node1> q= new LinkedList<>();
        q.offer(S);
        while(!q.isEmpty()){
            Node1 top=q.poll();
            if(top.x==T.x&&top.y==T.y){
                return top.step;
            }
            Node1 node=new Node1();
            for(int i=0;i<4;i++){//循环四次，得到四个相邻位置
                int newX=top.x+X[i];
                int newY=top.y+Y[i];
                if(test(newX,newY,n,m)){//位置 (newX,newY)有效
                    node.x=newX;node.y=newY;//设置Node的坐标是(newX,newY)
                    node.step=top.step+1;//Node层数为top的层数+1
                    q.offer(node);//将结点Node加入队列
                    inq[newX][newY]=true;//设置位置  (newX,newY) 已经入过队
                }
            }
        }
        return -1;//无法到达终点T时返回-1
    }

    /**
     * 5 5
     * .....
     * .*.*.
     * .*S*.
     * .***.
     * ...T*
     * 2 2 4 3
     */
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        in.nextLine();
        a=new String[n][m];
        inq=new Boolean[n][m];
        for(int i=0;i<n;i++){
            String[] str=in.nextLine().split("");
            for(int j=0;j<m;j++){
                a[i][j]=str[j];
                inq[i][j]=false;
            }
        }
        //起点和重点的坐标
        S.x=in.nextInt(); //2
        S.y=in.nextInt(); //2
        T.x=in.nextInt(); //4
        T.y=in.nextInt(); //3
        S.step=0;//初始化起点的层数为0，即S到S的最小步数为0
        System.out.println(bfs(n,m));
    }
}

class Node1{

    public static void main(String[] args) {
//        Integer a1 = 30;
//        int a2 = 30;
//        Integer a3 = Integer.valueOf(30);
//        Integer a4 = new Integer(30);
//        System.out.println(a3 == a4);

        int a = 0;
        while (a < 5){
            switch (a){
                case 0:
                case 3:a = a+2;
                break;
                case 1:
                case 2:a=a+3;
                break;
                default:a=a+5;
            }

        }
        System.out.println(a);



        double[] d;
        d = new double[10];
        d = new double[20];
        d = new double[30];
        d = new double[40];
        System.out.println(d.length);

    }

    int x,y;//位置(x,y)
    int step;//step为从起点S到达该位置的最少步数（即层数）
}